/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package game;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import game.Spieler.*;
import java.io.IOException;
import java.util.Scanner;
import java.util.concurrent.locks.ReentrantLock;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author Christian Friedli
 */
public class TestSpielFriedli implements Serializable, Runnable {

    private static List<Spieler> SpielerListe = new ArrayList<Spieler>();
    final static int MAXSPIELER = 4;
    private static int aktuellerSpieler;
    private Spieler Spieler[];
    static ReentrantLock lockd;
    static ReentrantLock lockd2;

    public static void main(String[] args) {


        lockd = new ReentrantLock();
        lockd2 = new ReentrantLock();
        lockd.lock();

        Thread th = new Thread(new TestSpielFriedli());
        th.start();
        try {
            System.in.read();
        } catch (IOException ex) {
            Logger.getLogger(TestSpielFriedli.class.getName()).log(Level.SEVERE, null, ex);
        }

        lockd.unlock();
        lockd2.lock();
        lockd.lock();
        try {
            th.join();
        } catch (InterruptedException ex) {
            Logger.getLogger(TestSpielFriedli.class.getName()).log(Level.SEVERE, null, ex);
        }

        System.out.println("Spiel ENDE");
    }

    public void GameMain() {

        lockd2.lock();

        // Anlegen der Spieler
        Spieler = new Spieler[MAXSPIELER + 1];
        for (int i = 1; i <= MAXSPIELER; i++) {
            Spieler[i] = new Spieler();
            SpielerListe.add(Spieler[i]);
        }





        // Spieler erzeugen
        Spieler[1] = new Spieler("Yanick", false, 1);
        SpielerListe.add(Spieler[1]);
        Spieler[2] = new Spieler("Tim", false, 2);
        SpielerListe.add(Spieler[2]);
        Spieler[3] = new Spieler("Sebi", false, 3);
        SpielerListe.add(Spieler[3]);
        Spieler[4] = new Spieler("Christian", false, 4);
        SpielerListe.add(Spieler[4]);

        // Reihenkarten legen - Reihenobjekte erstellen;       
        Reihe Reihe[] = new Reihe[4 + 1];
        for (int i = 1; i <= 4; i++) {
            Reihe[i] = new Reihe();
        }

        // Kartenstapel vorbereiten
        GemischterStapel GemischterStapel = new GemischterStapel();
        // Letze Rundekarte wurde noch nicht gezogen
        boolean letzteRundekarteGezogen = false;


        // Die Start-Farbkarten werden den Spielern zugeteilt
        // Jeder Spieler erhält einen andere Farbkarte
        // Start Farbkarte Spieler 1
        Farbkarte k1 = GemischterStapel.karteAufnehmen();
        GemischterStapel.letzteKarteLöschen();
        System.out.println("Start Farbkarte Spieler 1: " + k1.toString());
        Spieler[1].karteAufnehmen(k1);
        String s1 = k1.getFarbe(); // Kartenwert in einen String umwandeln für das anschiessende Vergleichen

        lockd.lock();

        // Start Farbkarte Spieler 2
        Farbkarte k2 = GemischterStapel.karteAufnehmen();
        GemischterStapel.letzteKarteLöschen();
        String s2 = k2.getFarbe();

        // ist die aufgenommene Karte die gleich wie die Karte von Spieler 1
        while (s2.equals(s1)) {
            k2 = GemischterStapel.neueKarte(k2);
            GemischterStapel.letzteKarteLöschen();
            s2 = k2.getFarbe();
        }
        // Karte Spieler 2 übergeben
        Spieler[2].karteAufnehmen(k2);
        System.out.println("Start Farbkarte Spieler 2: " + k2.toString());

        lockd.unlock();

        lockd2.unlock();

        // Start Farbkarte für Spieler 3
        Farbkarte k3 = GemischterStapel.karteAufnehmen();
        String s3 = k3.getFarbe();
        GemischterStapel.letzteKarteLöschen();

        // ist die aufgenommene Karte die gleich wie die Karte von Spieler 1 und 2
        while (s3.equals(s1) || s3.equals(s2)) {
            k3 = GemischterStapel.neueKarte(k3);
            GemischterStapel.letzteKarteLöschen();
            s3 = k3.getFarbe();
        }

        System.out.println("Start Farbkarte Spieler 3: " + k3.toString());
        // Karte Spieler 3 übergeben  
        Spieler[3].karteAufnehmen(k3);

        lockd.lock();

        Farbkarte k4 = GemischterStapel.karteAufnehmen();
        String s4 = k4.getFarbe();
        GemischterStapel.letzteKarteLöschen();

        // ist die aufgenommene Karte die gleich wie die Karte von Spieler 1, 2 und 3
        while (s4.equals(s1) || s4.equals(s2) || s4.equals(s3)) {
            k4 = GemischterStapel.neueKarte(k4);
            GemischterStapel.letzteKarteLöschen();
            s4 = k4.getFarbe();
        }

        System.out.println("Start Farbkarte Spieler 4: " + k4.toString());
        // Karte Spieler 4 übergeben  
        Spieler[4].karteAufnehmen(k4);

        // SPIEL START
        System.out.println("Spiel start");

        // Runde vorbereiten 
        // alle Spieler aktivieren
        for (int i = 1; i <= MAXSPIELER; i++) {
            Spieler[i].setIstAktiv(true);
        }
        // Spieler 1 fängt an
        aktuellerSpieler = 1;

        // Alle Reihen Aktivieren
        for (int i = 1; i <= 4; i++) {
            Reihe[i].ReiheAktivieren();
        }
        int anzahlAktiverReihen = 4;
        int anzahlAktiverVollerReihen = 0;


        // Spielschleife
        // Diese Schlaufe wird sollange durchlaufen, bis die letzte Rundekarte
        // gezogen wurde und keine aktiven Reihen mehr vorhanden sind
        while (letzteRundekarteGezogen == false && anzahlAktiverReihen > 0) {

            anzahlAktiverReihen = 4;
            anzahlAktiverVollerReihen = 0;

            // Spieler welcher an der Reihe ist fängt an:
            // Spieler 1 wenn es die erste Runde ist, ansonsten der Spieler 
            // welcher die letzte Reihe der vorhärigen Runde aufgenommen hat 
            // Spieler nimmt Karte vom Stapel und fügt sie einer Reihe hinzu
            Farbkarte gezogeneKarte = GemischterStapel.karteAufnehmen();    // ActionListener auf Stapel
            GemischterStapel.letzteKarteLöschen();
            Reihe[aktuellerSpieler].karteHinzufügen(gezogeneKarte);         // ActionListener auf Reihe

            // Rundenschleife
            // Solange noch Reihenkarten aktiv sind
            while (anzahlAktiverReihen > 0) {

                // Wie viele Reihenkarten sind aktiv und voll?
                // Wie viele Reihenkarten sind aktiv?
                for (int i = 1; i <= 4; i++) {
                    if (Reihe[i].reiheAktiv == true && Reihe[i].ReiheVoll() == true) {
                        anzahlAktiverVollerReihen++;
                    } else if (Reihe[i].reiheAktiv == false) {
                        anzahlAktiverReihen--;
                    } else;
                }

                // sind alle aktiven Reihen voll?
                // wenn ja:     Muss eine Reihenkarte aufgenommen werden            
                // wenn nein:   Karte vom Stapel nehmen und einer Reihenkarte zuteilen,
                //              oder eine Reihenkarte mit mindestens einer Karte aufnehmen
                if (anzahlAktiverReihen == anzahlAktiverVollerReihen) {
                    // es muss eine Reihenkarte aufgenommen werden
                    // .........
//                    Reihe ReiheAufgenommen = Reihe.;
//                    Spieler[aktuellerSpieler].karteAufnehmen(ReiheAufgenommen);

                    // Alle Reihenkarten dem Spieler übergeben


                    // Spieler inaktiv setzten
                    Spieler[aktuellerSpieler].setIstAktiv(false);
                    // Sind noch aktive Spieler vorhanden? Hat es noch aktive Reihenkarten? 
                    // Wenn es noch aktive Reihen hat, hat es auch noch aktive Spieler
                    if (anzahlAktiverReihen > 0) {
                        // aktuellerSpieler = nextPlayer(aktuellerSpieler);
                    } else {
                        if (letzteRundekarteGezogen == true) {
                            //SPIEL ENDE, highscoore anzeigen
                            int PunkteSpieler1 = Spieler[1].punkteZählen();
                            int PunkteSpieler2 = Spieler[2].punkteZählen();
                            int PunkteSpieler3 = Spieler[3].punkteZählen();
                            int PunkteSpieler4 = Spieler[4].punkteZählen();




                        } else {
                            // alle Spieler aktivieren
                            for (int i = 1; i <= MAXSPIELER; i++) {
                                Spieler[i].setIstAktiv(true);
                            }
                        }

                    }

                } else {
                    // es kann ein eine Reihenkarte oder eine Karte vom Stapel genommen werden

                    // Reihenkarte aufnehme
                    // ...........




                    // Karte vom Stapel nehmen und einer Reihe hinzufügen
                    gezogeneKarte = GemischterStapel.karteAufnehmen();    // ActionListener auf Stapel
                    GemischterStapel.letzteKarteLöschen();
                    // Ist die gezogene Karte letzte Rundekarte? Stapelgrösse 15?
                    if (GemischterStapel.stapelGroesse() == 15) {
                        letzteRundekarteGezogen = true;
                        System.out.println("Letze Runde");
                    }
                    Reihe[1].karteHinzufügen(gezogeneKarte);         // ActionListener auf Reihe

                    // nächster Spieler

                }

//        int c = Spieler[1].punkteZählen();
//        System.out.println(c);
//
//        int z = Spieler[2].punkteZählen();
//        System.out.println(z);
            }
            System.out.println("Runden ENDE");
        }

    }

    public int nextPlayer(int aktuellerSpieler) {
        int nextPlayer = 0;


        switch (aktuellerSpieler) {
            case 1:
                if (Spieler[2].IstAktiv()) {
                    nextPlayer = 2;
                    break;
                } else if (Spieler[3].IstAktiv()) {
                    nextPlayer = 3;
                    break;
                } else if (Spieler[4].IstAktiv()) {
                    nextPlayer = 4;
                    break;
                } else {
                    nextPlayer = 1;
                    break;
                }
            case 2:
                if (Spieler[3].IstAktiv()) {
                    nextPlayer = 3;
                    break;
                } else if (Spieler[4].IstAktiv()) {
                    nextPlayer = 4;
                    break;
                } else if (Spieler[1].IstAktiv()) {
                    nextPlayer = 1;
                    break;
                } else {
                    nextPlayer = 2;
                    break;
                }
            case 3:
                if (Spieler[4].IstAktiv()) {
                    nextPlayer = 4;
                    break;
                } else if (Spieler[1].IstAktiv()) {
                    nextPlayer = 1;
                    break;
                } else if (Spieler[2].IstAktiv()) {
                    nextPlayer = 2;
                    break;
                } else {
                    nextPlayer = 3;
                    break;
                }
            case 4:
                if (Spieler[1].IstAktiv()) {
                    nextPlayer = 1;
                    break;
                } else if (Spieler[2].IstAktiv()) {
                    nextPlayer = 2;
                    break;
                } else if (Spieler[3].IstAktiv()) {
                    nextPlayer = 3;
                    break;
                } else {
                    nextPlayer = 4;
                    break;
                }
        }
        return nextPlayer;
    }

    @Override
    public void run() {
        GameMain();
    }
}
